home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / misc / volume25 / pdksh / part08 < prev    next >
Encoding:
Text File  |  1991-11-12  |  54.1 KB  |  2,211 lines
  1. Newsgroups: comp.sources.misc
  2. From: sjg@zen.void.oz.au (Simon J. Gerraty)
  3. Subject:  v25i054:  pdksh - Public Domain Korn Shell, v4, Part08/09
  4. Message-ID: <1991Nov13.031239.16335@sparky.imd.sterling.com>
  5. X-Md4-Signature: d2a3ea33ae95c1dbadac751fda6e67bc
  6. Date: Wed, 13 Nov 1991 03:12:39 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: sjg@zen.void.oz.au (Simon J. Gerraty)
  10. Posting-number: Volume 25, Issue 54
  11. Archive-name: pdksh/part08
  12. Environment: UNIX
  13.  
  14. #! /bin/sh
  15. # into a shell via "sh file" or similar.  To overwrite existing files,
  16. # type "sh file -c".
  17. # The tool that generated this appeared in the comp.sources.unix newsgroup;
  18. # send mail to comp-sources-unix@uunet.uu.net if you want that tool.
  19. # Contents:  Makefile ReadMe.vimode sh/Changes sh/Makefile sh/config.h
  20. #   sh/tty.h sh/version.c std/Makefile std/posix/Makefile
  21. #   std/posix/dirent.C std/posix/dirent.H std/posix/fcntl.c
  22. #   std/posix/fcntl.h std/posix/fixincludes std/posix/times.c
  23. #   std/posix/times.h std/posix/unistd.c std/posix/unistd.h
  24. #   std/posix/wait.h std/stdc/Makefile std/stdc/clock.c
  25. #   std/stdc/fprintf.c std/stdc/limits.h std/stdc/memcmp.c
  26. #   std/stdc/memmove.c std/stdc/setvbuf.c std/stdc/sprintf.c
  27. #   std/stdc/stdarg.h std/stdc/stddef.h std/stdc/stdio.sed
  28. #   std/stdc/stdlib.h std/stdc/strchr.c std/stdc/strcmp.c
  29. #   std/stdc/strcspn.c std/stdc/string.h std/stdc/strncat.c
  30. #   std/stdc/strncmp.c std/stdc/strncpy.c std/stdc/strpbrk.c
  31. #   std/stdc/strrchr.c std/stdc/strspn.c std/stdc/strstr.c
  32. #   std/stdc/strtok.c std/stdc/time.h std/stdc/types.h
  33. # Wrapped by kent@sparky on Tue Nov 12 20:44:34 1991
  34. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  35. echo If this archive is complete, you will see the following message:
  36. echo '          "shar: End of archive 8 (of 9)."'
  37. if test -f 'Makefile' -a "${1}" != "-c" ; then 
  38.   echo shar: Will not clobber existing file \"'Makefile'\"
  39. else
  40.   echo shar: Extracting \"'Makefile'\" \(557 characters\)
  41.   sed "s/^X//" >'Makefile' <<'END_OF_FILE'
  42. X# PD Bourne/Korn Shell
  43. X# 
  44. X
  45. XSHELL=/bin/sh
  46. X
  47. X#CONFIG= -D_SYSV
  48. X#CONFIG= -D_BSD
  49. X#CONFIG= -D_V7
  50. X#CONFIG= -D_ST        /* Atari ST */
  51. X
  52. XMANPAGES = ksh.1
  53. X#INSTALL=bsdinstall
  54. XINSTALL=install
  55. X
  56. Xall:    ksh
  57. X
  58. Xksh:    libs
  59. X    ( cd sh ; $(MAKE) 'CC=$(CC)' 'CONFIG=$(CONFIG)' $@ )
  60. X
  61. Xlibs:
  62. X    ( cd std ; $(MAKE) 'CC=$(CC)' 'CONFIG=$(CONFIG)' $@ )
  63. X
  64. Xinstall: sh/ksh
  65. X    ( cd sh ; $(INSTALL) -s ksh $(HCRDESTDIR)/bin )
  66. X
  67. Xsh/ksh:    ksh
  68. X
  69. Xinst-man: $(MANPAGES)
  70. X    $(INSTALL) -c -m 444 $(MANPAGES) $(HCRDESTDIR)/man/u_man/man1
  71. X
  72. Xclean clobber:
  73. X    ( cd std ; $(MAKE) $@ )
  74. X    ( cd sh ; $(MAKE) $@ )
  75. X    -rm -f *.out
  76. X
  77. END_OF_FILE
  78.   if test 557 -ne `wc -c <'Makefile'`; then
  79.     echo shar: \"'Makefile'\" unpacked with wrong size!
  80.   fi
  81.   # end of 'Makefile'
  82. fi
  83. if test -f 'ReadMe.vimode' -a "${1}" != "-c" ; then 
  84.   echo shar: Will not clobber existing file \"'ReadMe.vimode'\"
  85. else
  86.   echo shar: Extracting \"'ReadMe.vimode'\" \(1317 characters\)
  87.   sed "s/^X//" >'ReadMe.vimode' <<'END_OF_FILE'
  88. X
  89. XThe changes I have made are all relevant to the VI edit mode. The vi-edit
  90. Xsource seems mostly complete, so these changes are minimal. What is available
  91. Xnow is pretty useful. I will make further fixes as I notice the bugs (or
  92. Xanyone else does).
  93. X
  94. XA summary of changes follows:
  95. X
  96. X1) two changes to turn on the vi-editing feature.
  97. X2) motion edit fix: back space and space bar now do something: have
  98. Xthe same behaviour as the 'h' and 'l' keys.
  99. X3) input edit fix: backspace key now works.
  100. X
  101. XKnown bugs (not fixed yet):
  102. X
  103. Xa) proviso on 1) and 2) above: the backspace key was hardwired to the
  104. X<delete> key. I have temporarily extended it to include the '^H' or
  105. X<backspace> key. I will generalize this to use whatever key is defined
  106. Xas the erase character by stty.
  107. X
  108. Xb) the interrupt key does not clear the edit buffer. This means the next
  109. Xedit command after an interrupt will be garbage.
  110. X
  111. Xc) Same sort of thing as b) occurs for the <EOF> key.
  112. X
  113. Xd) insertions near the beginning of an edit buffer seem to screw up the rest
  114. Xof the buffer.
  115. X
  116. XKnown missing features:
  117. X
  118. Xa) search edit commands: [count]-, [count]+
  119. Xb) text modification edit commands: P, p, *
  120. Xc) r (replace) doesn't seem to work too well.
  121. Xd) tilde does not do anything (should reverse upper to lower and vice versa)
  122. X
  123. Xe) ! in prompt doesn't get expanded to history number
  124. END_OF_FILE
  125.   if test 1317 -ne `wc -c <'ReadMe.vimode'`; then
  126.     echo shar: \"'ReadMe.vimode'\" unpacked with wrong size!
  127.   fi
  128.   # end of 'ReadMe.vimode'
  129. fi
  130. if test -f 'sh/Changes' -a "${1}" != "-c" ; then 
  131.   echo shar: Will not clobber existing file \"'sh/Changes'\"
  132. else
  133.   echo shar: Extracting \"'sh/Changes'\" \(596 characters\)
  134.   sed "s/^X//" >'sh/Changes' <<'END_OF_FILE'
  135. XFix echo $$ | cat
  136. X#if and config option cleanup
  137. XFix let evaluation of null/unset vars
  138. Xalloc improvement
  139. XFix accidental SCCS keywords
  140. XFix Xstring overwriting in lex.c
  141. XPrint here doc temp file when printing I/O actions
  142. XAdd more slack on end of Xstrings
  143. XFix up test(1) parsing
  144. XRun shell scripts with EXECSHELL
  145. XMake temp files 0600
  146. XMake unset -f work
  147. XMake trailing blank or tab in alias work
  148. XFix command completion bug
  149. X--------------------------------------------------
  150. XFix "cd / foo"
  151. XFix getopts accidentally resetting itself
  152. X--------------------------------------------------
  153. XFix whence exit codes
  154. END_OF_FILE
  155.   if test 596 -ne `wc -c <'sh/Changes'`; then
  156.     echo shar: \"'sh/Changes'\" unpacked with wrong size!
  157.   fi
  158.   # end of 'sh/Changes'
  159. fi
  160. if test -f 'sh/Makefile' -a "${1}" != "-c" ; then 
  161.   echo shar: Will not clobber existing file \"'sh/Makefile'\"
  162. else
  163.   echo shar: Extracting \"'sh/Makefile'\" \(1126 characters\)
  164.   sed "s/^X//" >'sh/Makefile' <<'END_OF_FILE'
  165. X# PD Bourne/Korn Shell
  166. X# NOTE: the are no depencies of .c file on .h files yet.
  167. X
  168. XSHELL = /bin/sh
  169. X
  170. X# This is for the sun386i your mileage may vary :-)
  171. X#CC=gcc -ansi -Dsun386 -Dsun -Di386
  172. X
  173. X#CONFIG= -D_SYSV
  174. XCONFIG= -D_BSD
  175. X
  176. XSTD=    ../std
  177. X
  178. X#CC = shcc
  179. XCCOPTS = $(DBG)
  180. XCFLAGS = $(CCOPTS) -I$(STD)/h $(CONFIG)
  181. X
  182. X#LDOPTS = -s
  183. XLDFLAGS = $(LDOPTS) -L$(STD)
  184. X
  185. XCOMPATLIBS =  -lstdc # -lposix
  186. X#OTHERLIBS = -lc_s
  187. X#OTHERLIBS = -ldirent
  188. XLDLIBS = $(COMPATLIBS) $(OTHERLIBS)
  189. X
  190. XHDRS =    sh.h table.h expand.h lex.h tree.h tty.h trace.h
  191. XSRCS1 =    version.c main.c misc.c trap.c alloc.c io.c \
  192. X    syn.c lex.c edit.c emacs.c vi.c history.c tree.c 
  193. XSRCS2 =    exec.c jobs.c \
  194. X    c_sh.c c_ksh.c c_test.c getopts.c ulimit.c \
  195. X    var.c table.c eval.c expr.c mail.c trace.c
  196. XSRCS =    Makefile $(HDRS) $(SRCS1) $(SRCS2) 
  197. X
  198. XOBJS =    version.o main.o misc.o \
  199. X    syn.o lex.o edit.o emacs.o vi.o tree.o \
  200. X    exec.o jobs.o trap.o \
  201. X    c_sh.o c_ksh.o c_test.o \
  202. X    ulimit.o getopts.o expr.o history.o \
  203. X    var.o table.o alloc.o io.o eval.o mail.o trace.o
  204. X
  205. Xksh: $(OBJS) 
  206. X    $(CC) $(LDFLAGS) -o $@ $(OBJS) $(LDLIBS)
  207. X
  208. Xclean:
  209. X    rm -f *.o *.out core
  210. X
  211. Xclobber: clean
  212. X    rm -f ksh
  213. X
  214. X
  215. Xedit.o emacs.o:    edit.h
  216. END_OF_FILE
  217.   if test 1126 -ne `wc -c <'sh/Makefile'`; then
  218.     echo shar: \"'sh/Makefile'\" unpacked with wrong size!
  219.   fi
  220.   # end of 'sh/Makefile'
  221. fi
  222. if test -f 'sh/config.h' -a "${1}" != "-c" ; then 
  223.   echo shar: Will not clobber existing file \"'sh/config.h'\"
  224. else
  225.   echo shar: Extracting \"'sh/config.h'\" \(594 characters\)
  226.   sed "s/^X//" >'sh/config.h' <<'END_OF_FILE'
  227. X/*
  228. X * Configuration file for the PD ksh
  229. X */
  230. X
  231. X#ifndef    _CONFIG_H
  232. X#define    _CONFIG_H
  233. X
  234. X/*
  235. X * Builtin edit modes
  236. X */
  237. X
  238. X#define    EMACS                /* EMACS-like mode */
  239. X#define    VI                /* vi-like mode */
  240. X
  241. X/*
  242. X * Various compilation options.  They are defined to 1 because
  243. X * the original code uses #if a lot, and some versions of cpp
  244. X * seem to choke on #if NOTDEF
  245. X */
  246. X
  247. X#define    JOBS            /* job control */
  248. X/* #define    FASCIST            /* Fascist getopts */
  249. X#define    SHARPBANG            /* Hack to handle #! */
  250. X/* #define    SILLY            /* Game of life in EMACS mode */
  251. X/* #define    SWTCH            /* Handle SWTCH for shl(1) */
  252. X
  253. X#endif    /* _CONFIG_H */
  254. END_OF_FILE
  255.   if test 594 -ne `wc -c <'sh/config.h'`; then
  256.     echo shar: \"'sh/config.h'\" unpacked with wrong size!
  257.   fi
  258.   # end of 'sh/config.h'
  259. fi
  260. if test -f 'sh/tty.h' -a "${1}" != "-c" ; then 
  261.   echo shar: Will not clobber existing file \"'sh/tty.h'\"
  262. else
  263.   echo shar: Extracting \"'sh/tty.h'\" \(596 characters\)
  264.   sed "s/^X//" >'sh/tty.h' <<'END_OF_FILE'
  265. X/*
  266. X    tty.h -- centralized definitions for a variety of terminal interfaces
  267. X
  268. X    created by DPK, Oct. 1986
  269. X
  270. X    last edit:    30-Jul-1987    D A Gwyn
  271. X*/
  272. X
  273. X#if _BSD_SYSV            /* BRL UNIX System V emulation */
  274. X#include <termio.h>    /* includes <sys/_ioctl.h> */
  275. X#ifndef NTTYDISC
  276. X#define    TIOCGETD    _IOR( 't', 0, int )
  277. X#define    TIOCSETD    _IOW( 't', 1, int )
  278. X#define    NTTYDISC    2
  279. X#endif
  280. X#ifndef TIOCSTI
  281. X#define    TIOCSTI        _IOW( 't', 114, char )
  282. X#endif
  283. X#ifndef TIOCSPGRP
  284. X#define    TIOCSPGRP    _IOW( 't', 118, int )
  285. X#endif
  286. X#else    /* !_BSD_SYSV */
  287. X#if _BSD
  288. X#include <sys/ioctl.h>
  289. X#else
  290. X#include <termio.h>
  291. X#endif
  292. X#endif    /* _BSD_SYSV */
  293. END_OF_FILE
  294.   if test 596 -ne `wc -c <'sh/tty.h'`; then
  295.     echo shar: \"'sh/tty.h'\" unpacked with wrong size!
  296.   fi
  297.   # end of 'sh/tty.h'
  298. fi
  299. if test -f 'sh/version.c' -a "${1}" != "-c" ; then 
  300.   echo shar: Will not clobber existing file \"'sh/version.c'\"
  301. else
  302.   echo shar: Extracting \"'sh/version.c'\" \(751 characters\)
  303.   sed "s/^X//" >'sh/version.c' <<'END_OF_FILE'
  304. X/*
  305. X * value of $KSH_VERSION
  306. X */
  307. X
  308. X#ifndef lint
  309. Xstatic char *RCSid = "$Id: version.c,v 3.3 89/03/27 15:52:29 egisin Exp $";
  310. Xstatic char *sccs_id = "@(#)version.c    4.1 91/11/09 14:55:16 (sjg)";
  311. X#endif
  312. X
  313. X#include <stddef.h>
  314. X#include <setjmp.h>
  315. X#include "sh.h"
  316. X
  317. Xchar ksh_version [] =
  318. X    "KSH_VERSION=@(#)PD KSH v4.1 91/11/09 14:55:16";
  319. X
  320. X/***
  321. X$Log:    version.c,v $
  322. XVersion  4.0  91/11/09  sjg
  323. Xdistribution
  324. XRevision 3.3  89/03/27  15:52:29  egisin
  325. Xdistribution
  326. X
  327. XRevision 3.2  88/12/14  20:10:41  egisin
  328. Xmany fixes
  329. X
  330. XRevision 3.1  88/11/03  09:18:36  egisin
  331. Xalpha distribution
  332. X
  333. XRevision 1.3  88/10/20  17:34:03  egisin
  334. Xadded @(#) to ksh_version
  335. X
  336. XRevision 1.2  88/09/27  19:01:58  egisin
  337. Xfix version.c
  338. X
  339. XRevision 1.1  88/09/27  18:59:06  egisin
  340. XInitial revision
  341. X***/
  342. X
  343. END_OF_FILE
  344.   if test 751 -ne `wc -c <'sh/version.c'`; then
  345.     echo shar: \"'sh/version.c'\" unpacked with wrong size!
  346.   fi
  347.   # end of 'sh/version.c'
  348. fi
  349. if test -f 'std/Makefile' -a "${1}" != "-c" ; then 
  350.   echo shar: Will not clobber existing file \"'std/Makefile'\"
  351. else
  352.   echo shar: Extracting \"'std/Makefile'\" \(760 characters\)
  353.   sed "s/^X//" >'std/Makefile' <<'END_OF_FILE'
  354. X#
  355. X# Makefile for the compatibility libraries
  356. X#
  357. X
  358. XSHELL = /bin/sh
  359. X
  360. X#CONFIG = -D_SYSV
  361. XCONFIG = -D_BSD
  362. X
  363. XLN = ln
  364. X
  365. Xlibs:    h libstdc.a #libposix.a
  366. X
  367. Xh:
  368. X    mkdir h
  369. X    ( cd stdc ; $(MAKE) 'CC=$(CC)' 'CONFIG=$(CONFIG)' clobber link )
  370. X    ( cd posix  ; $(MAKE) 'CC=$(CC)' 'CONFIG=$(CONFIG)' clobber link )
  371. X
  372. Xlibstdc.a: FORCED
  373. X    ( cd stdc ; $(MAKE) 'CC=$(CC)' 'CONFIG=$(CONFIG)' $@ )
  374. X    -$(LN) stdc/$@ $@
  375. X
  376. Xlibposix.a: FORCED
  377. X    ( cd posix ; $(MAKE) 'CC=$(CC)' 'CONFIG=$(CONFIG)' $@ )
  378. X    -$(LN) posix/$@ .
  379. X
  380. Xclean:
  381. X    -rm -f *.out
  382. X    ( cd stdc ; $(MAKE) 'CC=$(CC)' 'CONFIG=$(CONFIG)' $@ )
  383. X    ( cd posix  ; $(MAKE) 'CC=$(CC)' 'CONFIG=$(CONFIG)' $@ )
  384. X
  385. Xclobber:
  386. X    -rm -rf h *.a
  387. X    ( cd stdc ; $(MAKE) 'CC=$(CC)' 'CONFIG=$(CONFIG)' $@ )
  388. X    ( cd posix  ; $(MAKE) 'CC=$(CC)' 'CONFIG=$(CONFIG)' $@ )
  389. X
  390. XFORCED:
  391. END_OF_FILE
  392.   if test 760 -ne `wc -c <'std/Makefile'`; then
  393.     echo shar: \"'std/Makefile'\" unpacked with wrong size!
  394.   fi
  395.   # end of 'std/Makefile'
  396. fi
  397. if test -f 'std/posix/Makefile' -a "${1}" != "-c" ; then 
  398.   echo shar: Will not clobber existing file \"'std/posix/Makefile'\"
  399. else
  400.   echo shar: Extracting \"'std/posix/Makefile'\" \(847 characters\)
  401.   sed "s/^X//" >'std/posix/Makefile' <<'END_OF_FILE'
  402. X# POSIX P1003.1 compatability
  403. X
  404. XSHELL = /bin/sh
  405. X
  406. X# This is for the sun386i your mileage may vary :-)
  407. X#CC=gcc -ansi -Dsun386 -Dsun -Di386
  408. X
  409. X#CONFIG = -D_SYSV
  410. XCONFIG = -D_BSD
  411. X
  412. XLN = ln
  413. XRANLIB = ranlib        # For BSD systems
  414. X#RANLIB = echo Updated
  415. X
  416. XLIB = libposix.a
  417. XINCL = ../h
  418. X
  419. XCFLAGS = $(CCOPTS) -I$(INCL) $(CONFIG)
  420. X
  421. XMISC =    Makefile 
  422. XHDRS =    io.h wait.h times.h unistd.h fcntl.h dirent.h 
  423. XSRCS =    unistd.c fcntl.c times.c dup2.c
  424. XOBJS =    unistd.o fcntl.o times.o dup2.o
  425. X
  426. Xall:    $(LIB)
  427. X
  428. Xlink:    $(HDRS)
  429. X    [ -d $(INCL) ] || mkdir $(INCL)
  430. X    [ -d $(INCL)/sys ] || mkdir $(INCL)/sys
  431. X    -$(LN) wait.h time.h times.h $(INCL)/sys
  432. X    -$(LN) io.h fcntl.h unistd.h $(INCL)
  433. X    -if [ ! -r /usr/include/unistd.h ]; then $(LN) dirent.h $(INCL); fi
  434. X
  435. X$(LIB):    $(OBJS)
  436. X    ar r $@ $?
  437. X    $(RANLIB) $@
  438. X
  439. Xclean:
  440. X    -rm -f *.o *.out
  441. X
  442. Xclobber: clean
  443. X    -rm -f $(LIB)
  444. X
  445. Xfcntl.o: fcntl.h 
  446. X
  447. Xtimes.o: times.h 
  448. END_OF_FILE
  449.   if test 847 -ne `wc -c <'std/posix/Makefile'`; then
  450.     echo shar: \"'std/posix/Makefile'\" unpacked with wrong size!
  451.   fi
  452.   # end of 'std/posix/Makefile'
  453. fi
  454. if test -f 'std/posix/dirent.C' -a "${1}" != "-c" ; then 
  455.   echo shar: Will not clobber existing file \"'std/posix/dirent.C'\"
  456. else
  457.   echo shar: Extracting \"'std/posix/dirent.C'\" \(1037 characters\)
  458.   sed "s/^X//" >'std/posix/dirent.C' <<'END_OF_FILE'
  459. X/*
  460. X * simple implementation of directory(3) routines for V7 and Minix.
  461. X * completly untested. not designed to be efficient.
  462. X * missing telldir and seekdir.
  463. X */
  464. X
  465. X#include <sys/types.h>
  466. X#include <dirent.h>
  467. X
  468. Xchar    *malloc();
  469. X
  470. X#define    DIRSIZ    14
  471. Xstruct    direct_v7
  472. X{
  473. X    unsigned short    d_ino;
  474. X    char    d_name[DIRSIZ];
  475. X};
  476. X
  477. XDIR *opendir(filename)
  478. X    char *filename;
  479. X{
  480. X    DIR *dirp;
  481. X
  482. X    dirp = (DIR *) malloc(sizeof(DIR));
  483. X    if (dirp == NULL)
  484. X        return NULL;
  485. X    dirp->fd = open(filename, 0);
  486. X    if (dirp->fd < 0) {
  487. X        free((char *) dirp);
  488. X        return NULL;
  489. X    }
  490. X    return dirp;
  491. X}
  492. X
  493. Xstruct dirent *readdir(dirp)
  494. X    register DIR *dirp;
  495. X{
  496. X    static    struct direct_v7 ent;
  497. X
  498. X    while (read(dirp->fd, (char *)&ent, (int)sizeof(ent)) == sizeof(ent))
  499. X        if (ent.d_ino != 0)
  500. X            goto found;
  501. X    return (struct dirent *) NULL;
  502. X found:
  503. X    dirp->ent.d_ino = ent.d_ino;
  504. X    strncpy(dirp->ent.d_name, ent.d_name, DIRSIZ);
  505. X    return &dirp->ent;
  506. X}
  507. X
  508. Xvoid rewinddir(dirp)
  509. X    DIR *dirp;
  510. X{
  511. X    lseek(dirp->fd, 0L, 0);
  512. X}
  513. X
  514. Xclosedir(dirp)
  515. X    DIR *dirp;
  516. X{
  517. X    close(dirp->fd);
  518. X    dirp->fd = -1;
  519. X    free((char *) dirp);
  520. X    return 0;
  521. X}
  522. END_OF_FILE
  523.   if test 1037 -ne `wc -c <'std/posix/dirent.C'`; then
  524.     echo shar: \"'std/posix/dirent.C'\" unpacked with wrong size!
  525.   fi
  526.   # end of 'std/posix/dirent.C'
  527. fi
  528. if test -f 'std/posix/dirent.H' -a "${1}" != "-c" ; then 
  529.   echo shar: Will not clobber existing file \"'std/posix/dirent.H'\"
  530. else
  531.   echo shar: Extracting \"'std/posix/dirent.H'\" \(880 characters\)
  532.   sed "s/^X//" >'std/posix/dirent.H' <<'END_OF_FILE'
  533. X/*
  534. X    <sys/dirent.h> -- file system independent directory entry (SVR3)
  535. X
  536. X    last edit:    25-Apr-1987    D A Gwyn
  537. X    last hack:    14-Aug-1987    Eric Gisin
  538. X
  539. X    prerequisite:    <sys/types.h>
  540. X*/
  541. X
  542. X#define    MAXNAMLEN    16        /* maximum filename length */
  543. X
  544. Xstruct dirent                /* data from getdents()/readdir() */
  545. X    {
  546. X    long        d_ino;        /* inode number of entry */
  547. X    off_t        d_off;        /* offset of disk directory entry */
  548. X    unsigned short    d_reclen;    /* length of this record */
  549. X    char    d_name[MAXNAMLEN];    /* name of file */
  550. X};
  551. X
  552. X#ifndef NAME_MAX
  553. X#define    NAME_MAX    (MAXNAMLEN - 1)    /* DAG -- added for POSIX */
  554. X#endif
  555. X
  556. Xtypedef struct {            /* returned by opendir() */
  557. X    int    fd;
  558. X    struct dirent ent;
  559. X} DIR;
  560. X
  561. Xextern DIR        *opendir();
  562. Xextern struct dirent    *readdir();
  563. Xextern off_t        telldir();
  564. Xextern void        seekdir();
  565. Xextern void        rewinddir();
  566. Xextern int        closedir();
  567. X
  568. X#ifndef NULL
  569. X#define    NULL    0            /* DAG -- added for convenience */
  570. X#endif
  571. END_OF_FILE
  572.   if test 880 -ne `wc -c <'std/posix/dirent.H'`; then
  573.     echo shar: \"'std/posix/dirent.H'\" unpacked with wrong size!
  574.   fi
  575.   # end of 'std/posix/dirent.H'
  576. fi
  577. if test -f 'std/posix/fcntl.c' -a "${1}" != "-c" ; then 
  578.   echo shar: Will not clobber existing file \"'std/posix/fcntl.c'\"
  579. else
  580.   echo shar: Extracting \"'std/posix/fcntl.c'\" \(430 characters\)
  581.   sed "s/^X//" >'std/posix/fcntl.c' <<'END_OF_FILE'
  582. X/* fcntl emulation */
  583. X
  584. X#include <errno.h>
  585. X#include <sys/types.h>
  586. X#include <unistd.h>
  587. X#include <fcntl.h>
  588. X
  589. X#if _V7
  590. X
  591. X#include <sgtty.h>
  592. X
  593. Xint
  594. Xfcntl(fd, cmd, arg)
  595. X    int fd, cmd, arg;
  596. X{
  597. X    switch (cmd) {
  598. X      case F_SETFD:        /* set fd flags */
  599. X        ioctl(fd, (arg&FD_CLEXEC) ? FIOCLEX : FIONCLEX, (char *)NULL);
  600. X        break;
  601. X      case F_DUPFD:        /* dup fd */
  602. X        /* this one is fun. find an unused fd >= arg and dup2 */
  603. X        break;
  604. X    }
  605. X    return 0;
  606. X}
  607. X
  608. X#endif
  609. X
  610. END_OF_FILE
  611.   if test 430 -ne `wc -c <'std/posix/fcntl.c'`; then
  612.     echo shar: \"'std/posix/fcntl.c'\" unpacked with wrong size!
  613.   fi
  614.   # end of 'std/posix/fcntl.c'
  615. fi
  616. if test -f 'std/posix/fcntl.h' -a "${1}" != "-c" ; then 
  617.   echo shar: Will not clobber existing file \"'std/posix/fcntl.h'\"
  618. else
  619.   echo shar: Extracting \"'std/posix/fcntl.h'\" \(437 characters\)
  620.   sed "s/^X//" >'std/posix/fcntl.h' <<'END_OF_FILE'
  621. X/* P1003.1 fcntl/open definitions */
  622. X/* Based on a version by Terrence W. Holm */
  623. X
  624. X/*  for fcntl(2)  */
  625. X
  626. X#define    F_DUPFD        0
  627. X#define    F_GETFD        1
  628. X#define    F_SETFD        2
  629. X#define    F_GETFL        3
  630. X#define    F_SETFL        4
  631. X
  632. X#define    FD_CLEXEC    1        /* fcntl F_SETFD close on exec mode */
  633. X
  634. X/*  for open(2)  */
  635. X
  636. X#define    O_RDONLY    0
  637. X#define    O_WRONLY    1
  638. X#define    O_RDWR        2
  639. X
  640. X#if _BSD
  641. X#undef    O_RDONLY
  642. X#undef    O_WRONLY
  643. X#undef    O_RDWR
  644. X#include "/./usr/include/fcntl.h"
  645. X#endif
  646. X
  647. END_OF_FILE
  648.   if test 437 -ne `wc -c <'std/posix/fcntl.h'`; then
  649.     echo shar: \"'std/posix/fcntl.h'\" unpacked with wrong size!
  650.   fi
  651.   # end of 'std/posix/fcntl.h'
  652. fi
  653. if test -f 'std/posix/fixincludes' -a "${1}" != "-c" ; then 
  654.   echo shar: Will not clobber existing file \"'std/posix/fixincludes'\"
  655. else
  656.   echo shar: Extracting \"'std/posix/fixincludes'\" \(799 characters\)
  657.   sed "s/^X//" >'std/posix/fixincludes' <<'END_OF_FILE'
  658. X# Install modified versions of certain ANSI-incompatible system header files
  659. X# which are fixed to work correctly with ANSI C
  660. X# and placed in a directory that GNU C will search.
  661. X# This works properly on a Sun in system version 3.4;
  662. X# for other versions, you had better check.
  663. X
  664. Xmkdir /usr/local/lib/gcc-include
  665. Xmkdir /usr/local/lib/gcc-include/sys
  666. Xcp /usr/include/sys/ioctl.h /usr/local/lib/gcc-include/sys/ioctl.h
  667. Xchmod +w /usr/local/lib/gcc-include/sys/ioctl.h
  668. Xex /usr/local/lib/gcc-include/sys/ioctl.h <<\EOF
  669. Xg/_IO/s/(\(.\),/('\1',/
  670. Xg/#define._IO/s/'x'/x/g
  671. Xwq
  672. XEOF
  673. X
  674. Xcp /usr/include/sys/ttychars.h /usr/local/lib/gcc-include/sys/ttychars.h
  675. Xchmod +w /usr/local/lib/gcc-include/sys/ttychars.h
  676. Xex /usr/local/lib/gcc-include/sys/ttychars.h <<\EOF
  677. Xg/CTRL/s/(\(.\))/('\1')/
  678. Xg/#define.CTRL/s/'c'/c/g
  679. Xwq
  680. XEOF
  681. END_OF_FILE
  682.   if test 799 -ne `wc -c <'std/posix/fixincludes'`; then
  683.     echo shar: \"'std/posix/fixincludes'\" unpacked with wrong size!
  684.   fi
  685.   # end of 'std/posix/fixincludes'
  686. fi
  687. if test -f 'std/posix/times.c' -a "${1}" != "-c" ; then 
  688.   echo shar: Will not clobber existing file \"'std/posix/times.c'\"
  689. else
  690.   echo shar: Extracting \"'std/posix/times.c'\" \(1126 characters\)
  691.   sed "s/^X//" >'std/posix/times.c' <<'END_OF_FILE'
  692. X/* P1003.1 times emulation */
  693. X
  694. X#include <sys/times.h>
  695. X
  696. X#if _BSD
  697. X
  698. X#include <sys/time.h>
  699. X#include <sys/resource.h>
  700. X
  701. Xstatic    long base_tv_sec = 0;
  702. X
  703. Xclock_t
  704. Xtimes(tmsp)
  705. X    register struct tms *tmsp;
  706. X{
  707. X    struct timeval tv;
  708. X    struct rusage ru;
  709. X
  710. X    getrusage(RUSAGE_SELF, &ru);
  711. X    tmsp->tms_utime = ru.ru_utime.tv_sec*CLK_TCK
  712. X        + (long)ru.ru_utime.tv_usec*CLK_TCK/1000000;
  713. X    tmsp->tms_stime = ru.ru_stime.tv_sec*CLK_TCK
  714. X        + (long)ru.ru_stime.tv_usec*CLK_TCK/1000000;
  715. X    getrusage(RUSAGE_CHILDREN, &ru);
  716. X    tmsp->tms_cutime = ru.ru_utime.tv_sec*CLK_TCK
  717. X        + (long)ru.ru_utime.tv_usec*CLK_TCK/1000000;
  718. X    tmsp->tms_cstime = ru.ru_stime.tv_sec*CLK_TCK
  719. X        + (long)ru.ru_stime.tv_usec*CLK_TCK/1000000;
  720. X
  721. X    gettimeofday(&tv, (struct timezone *)NULL);
  722. X    if (base_tv_sec == 0)
  723. X        base_tv_sec = tv.tv_sec;
  724. X    tv.tv_sec -= base_tv_sec; /*  prevent clock_t overflow */
  725. X    return tv.tv_sec*CLK_TCK + (long)tv.tv_usec*CLK_TCK/1000000;
  726. X}
  727. X
  728. X#endif
  729. X
  730. X#if _V7
  731. X
  732. Xclock_t
  733. Xtimes(tmsp)
  734. X    struct tms *tmsp;
  735. X{
  736. X    struct timeb tb;
  737. X
  738. X#undef times            /* access real times() */
  739. X    times(tmsp);
  740. X#define times times_
  741. X    ftime(&tb);
  742. X    return tb.time*CLK_TCK + (long)tb.millitm*CLK_TCK/1000;
  743. X}
  744. X
  745. X#endif
  746. X
  747. END_OF_FILE
  748.   if test 1126 -ne `wc -c <'std/posix/times.c'`; then
  749.     echo shar: \"'std/posix/times.c'\" unpacked with wrong size!
  750.   fi
  751.   # end of 'std/posix/times.c'
  752. fi
  753. if test -f 'std/posix/times.h' -a "${1}" != "-c" ; then 
  754.   echo shar: Will not clobber existing file \"'std/posix/times.h'\"
  755. else
  756.   echo shar: Extracting \"'std/posix/times.h'\" \(355 characters\)
  757.   sed "s/^X//" >'std/posix/times.h' <<'END_OF_FILE'
  758. X/*
  759. X * sys/times.h: POSIX times()
  760. X */
  761. X
  762. X#if ! _TIMES_H
  763. X#define    _TIMES_H 1
  764. X
  765. X#include <time.h>        /* defines CLK_TCK */
  766. X
  767. X#if __STDC__
  768. X#define    ARGS(args)    args
  769. X#else
  770. X#define    ARGS(args)    ()
  771. X#endif
  772. X
  773. Xstruct tms {
  774. X    clock_t    tms_utime, tms_stime;
  775. X    clock_t    tms_cutime, tms_cstime;
  776. X};
  777. X
  778. X#if _V7
  779. X#define times times_
  780. X#endif
  781. X
  782. Xclock_t    times ARGS((struct tms *tmsp));
  783. X
  784. X#endif
  785. X
  786. END_OF_FILE
  787.   if test 355 -ne `wc -c <'std/posix/times.h'`; then
  788.     echo shar: \"'std/posix/times.h'\" unpacked with wrong size!
  789.   fi
  790.   # end of 'std/posix/times.h'
  791. fi
  792. if test -f 'std/posix/unistd.c' -a "${1}" != "-c" ; then 
  793.   echo shar: Will not clobber existing file \"'std/posix/unistd.c'\"
  794. else
  795.   echo shar: Extracting \"'std/posix/unistd.c'\" \(459 characters\)
  796.   sed "s/^X//" >'std/posix/unistd.c' <<'END_OF_FILE'
  797. X/* misc. POSIX emulation */
  798. X
  799. X/* $Header$ */
  800. X
  801. X#include <string.h>
  802. X#include <errno.h>
  803. X#include <sys/types.h>
  804. X#include <unistd.h>
  805. X
  806. X#if _V7 || _BSD
  807. X
  808. Xchar *
  809. Xgetcwd(buf, len)
  810. X    char *buf;
  811. X    size_t len;
  812. X{
  813. X    char cwd [1024];
  814. X    extern char *getwd();
  815. X    if (getwd(cwd) == NULL)
  816. X        return NULL;
  817. X    if (strlen(cwd)+1 >= len) {
  818. X        errno = ERANGE;
  819. X        return NULL;
  820. X    }
  821. X    return strcpy(buf, cwd);
  822. X}
  823. X
  824. X#endif
  825. X
  826. X#if _V7
  827. X
  828. Xlong
  829. Xulimit(cmd, limit)
  830. X    int cmd;
  831. X    long limit;
  832. X{
  833. X    return 0;
  834. X}
  835. X
  836. X#endif
  837. X
  838. END_OF_FILE
  839.   if test 459 -ne `wc -c <'std/posix/unistd.c'`; then
  840.     echo shar: \"'std/posix/unistd.c'\" unpacked with wrong size!
  841.   fi
  842.   # end of 'std/posix/unistd.c'
  843. fi
  844. if test -f 'std/posix/unistd.h' -a "${1}" != "-c" ; then 
  845.   echo shar: Will not clobber existing file \"'std/posix/unistd.h'\"
  846. else
  847.   echo shar: Extracting \"'std/posix/unistd.h'\" \(782 characters\)
  848.   sed "s/^X//" >'std/posix/unistd.h' <<'END_OF_FILE'
  849. X/* unistd.h: misc. P1003.1 definitions */
  850. X/* Based on a version by Terrence W. Holm */
  851. X
  852. X#if ! _UNISTD_H
  853. X#define    _UNISTD_H 1
  854. X
  855. X#include <stddef.h>
  856. X
  857. X/* doesn't really belong here, but the library function need it */
  858. X/* todo: use _ARGS, _Void, _Const */
  859. X#if __STDC__
  860. X#define    ARGS(args)    args
  861. X#define Void    void
  862. X#define    Const    const
  863. X#else
  864. X#define    ARGS(args)    ()
  865. X#define    Void    char
  866. X#define    Const
  867. X#endif
  868. X
  869. X#include <io.h>            /* POSIX IO functions */
  870. X
  871. X/*  for access(2)  */
  872. X
  873. X#define    R_OK    4
  874. X#define    W_OK    2
  875. X#define    X_OK    1
  876. X#define    F_OK    0
  877. X
  878. X/*  for lockf(2)  */
  879. X
  880. X#define    F_ULOCK    0
  881. X#define    F_LOCK    1
  882. X#define    F_TLOCK    2
  883. X#define    F_TEST    3
  884. X
  885. X/*  for lseek(2)  */
  886. X
  887. X#define    SEEK_SET    0
  888. X#define    SEEK_CUR    1
  889. X#define    SEEK_END    2
  890. X
  891. X#define    IN_PATH    "/usr/include"
  892. X
  893. Xchar   *getcwd ARGS ((char *buf, size_t len));
  894. X
  895. X#endif
  896. X
  897. END_OF_FILE
  898.   if test 782 -ne `wc -c <'std/posix/unistd.h'`; then
  899.     echo shar: \"'std/posix/unistd.h'\" unpacked with wrong size!
  900.   fi
  901.   # end of 'std/posix/unistd.h'
  902. fi
  903. if test -f 'std/posix/wait.h' -a "${1}" != "-c" ; then 
  904.   echo shar: Will not clobber existing file \"'std/posix/wait.h'\"
  905. else
  906.   echo shar: Extracting \"'std/posix/wait.h'\" \(1017 characters\)
  907.   sed "s/^X//" >'std/posix/wait.h' <<'END_OF_FILE'
  908. X/*
  909. X * POSIX <sys/wait.h>
  910. X */
  911. X#if __STDC__
  912. X#define    ARGS(args)    args
  913. X#else
  914. X#define    ARGS(args)    ()
  915. X#endif
  916. X
  917. X#ifndef sparc
  918. Xtypedef int pid_t;        /* belong in sys/types.h */
  919. X#endif
  920. X
  921. X#ifdef sparc
  922. X# include "/usr/include/sys/wait.h"
  923. X#else
  924. X
  925. X/* waitpid options */
  926. X#define WNOHANG        1    /* don't hang in wait */
  927. X#define WUNTRACED    2    /* tell about stopped, untraced children */
  928. X
  929. X#define    WSTOPPED    0x7F    /* process is stopped */
  930. X
  931. X#define WIFSTOPPED(x)    (((x)&0xFF) == 0x7F)
  932. X#define WIFSIGNALED(x)    (((x)&0xFF) != 0x7F && ((x)&0x7F) != 0)
  933. X#define WIFEXITED(x)    (((x)&0xFF) != 0x7F && ((x)&0x7F) == 0)
  934. X#define    WIFCORED(x)    (!!((x)&0x80)) /* non-standard */
  935. X#define    WEXITSTATUS(x)    ((x)>>8&0xFF)
  936. X#define    WTERMSIG(x)    ((x)&0x7F)
  937. X#define    WSTOPSIG(x)    ((x)>>8&0xFF)
  938. X
  939. Xpid_t wait ARGS((int *statp));
  940. X#if _BSD
  941. Xpid_t wait3 ARGS((int *statp, int options, Void *));
  942. X/* todo: does not emulate pid argument */
  943. X#define    waitpid(pid, sp, opts)    wait3(sp, opts, (Void*)NULL)
  944. X#else
  945. Xpid_t waitpid ARGS((pid_t pid, int *statp, int options));
  946. X#endif
  947. X
  948. X#endif /* sparc */
  949. END_OF_FILE
  950.   if test 1017 -ne `wc -c <'std/posix/wait.h'`; then
  951.     echo shar: \"'std/posix/wait.h'\" unpacked with wrong size!
  952.   fi
  953.   # end of 'std/posix/wait.h'
  954. fi
  955. if test -f 'std/stdc/Makefile' -a "${1}" != "-c" ; then 
  956.   echo shar: Will not clobber existing file \"'std/stdc/Makefile'\"
  957. else
  958.   echo shar: Extracting \"'std/stdc/Makefile'\" \(1235 characters\)
  959.   sed "s/^X//" >'std/stdc/Makefile' <<'END_OF_FILE'
  960. X# Standard C (ANSI) compatabilaty
  961. X
  962. XSHELL = /bin/sh
  963. X
  964. X# This is for the sun386i your mileage may vary :-)
  965. X#CC=gcc -ansi -Dsun386 -Dsun -Di386
  966. X
  967. X#CONFIG = -D_SYSV
  968. XCONFIG = -D_BSD
  969. X
  970. XLN = ln
  971. XRANLIB = ranlib        # For BSD systems
  972. X#RANLIB = echo Updated
  973. X
  974. XLIB = libstdc.a
  975. XINCL = ../h
  976. X
  977. XCFLAGS = $(CCOPTS) -I$(INCL) $(CONFIG)
  978. X
  979. XMISC =    Makefile stdio.h_std
  980. XHDRS =    limits.h stddef.h stdlib.h string.h time.h stdarg.h 
  981. XSRCS =    strstr.c memmove.c stdio.c #clock.c
  982. XOBJS =    strstr.o memmove.o stdio.o #clock.o 
  983. X
  984. Xall:    $(LIB)
  985. X
  986. Xlink:    $(HDRS) stdio.h 
  987. X    [ -d $(INCL) ] || mkdir $(INCL)
  988. X    [ -d $(INCL)/sys ] || mkdir $(INCL)/sys
  989. X    -$(LN) types.h $(INCL)/sys
  990. X    -$(LN) limits.h stddef.h stdlib.h stdio.h string.h time.h stdarg.h $(INCL)
  991. X
  992. X$(LIB):    $(OBJS)
  993. X    ar r $@ $?
  994. X    $(RANLIB) $@
  995. X
  996. Xstdio.h: stdio.h_std stdio.sed /usr/include/stdio.h 
  997. X    sed -f stdio.sed </usr/include/stdio.h >stdio.hacked
  998. X    sed <stdio.h_std >stdio.h -e '/%%%/ r stdio.hacked'
  999. X    rm stdio.hacked
  1000. X
  1001. Xclean:
  1002. X    -rm -f *.o *.out stdio.hacked
  1003. X
  1004. Xclobber: clean
  1005. X    -rm -f $(LIB) stdio.h
  1006. X
  1007. Xstring.h: stddef.h
  1008. X
  1009. Xstdlib.h: stddef.h
  1010. X
  1011. Xstdio.h: stddef.h 
  1012. X
  1013. Xtime.h: stddef.h
  1014. X
  1015. Xstdio.o: stdio.h
  1016. X
  1017. Xsetvbuf.o: stdlib.h stdio.h
  1018. X
  1019. Xfprintf.o: stdarg.h stdio.h
  1020. X
  1021. Xsprintf.o: stdarg.h stdio.h
  1022. X
  1023. Xvprintf.o: stdarg.h stdio.h
  1024. X
  1025. Xstrstr.o: string.h 
  1026. X
  1027. END_OF_FILE
  1028.   if test 1235 -ne `wc -c <'std/stdc/Makefile'`; then
  1029.     echo shar: \"'std/stdc/Makefile'\" unpacked with wrong size!
  1030.   fi
  1031.   # end of 'std/stdc/Makefile'
  1032. fi
  1033. if test -f 'std/stdc/clock.c' -a "${1}" != "-c" ; then 
  1034.   echo shar: Will not clobber existing file \"'std/stdc/clock.c'\"
  1035. else
  1036.   echo shar: Extracting \"'std/stdc/clock.c'\" \(735 characters\)
  1037.   sed "s/^X//" >'std/stdc/clock.c' <<'END_OF_FILE'
  1038. X/* clock() */
  1039. X
  1040. X#include <time.h>
  1041. X
  1042. X#if _BSD
  1043. X
  1044. X#include <sys/time.h>
  1045. X#include <sys/resource.h>
  1046. X
  1047. Xclock_t
  1048. Xclock()
  1049. X{
  1050. X    struct timeval tv;
  1051. X    struct rusage ru;
  1052. X
  1053. X    getrusage(RUSAGE_SELF, &ru);
  1054. X    tv.tv_sec = ru.ru_utime.tv_sec + ru.ru_stime.tv_sec;
  1055. X    tv.tv_usec = ru.ru_utime.tv_usec + ru.ru_stime.tv_usec;
  1056. X    return tv.tv_sec*CLK_TCK + (long)tv.tv_usec*CLK_TCK/1000000;
  1057. X}
  1058. X
  1059. X#endif
  1060. X
  1061. X#if _V7 || _SYSV
  1062. X
  1063. X#include <sys/times.h>
  1064. X
  1065. Xclock_t
  1066. Xclock()
  1067. X{
  1068. X    struct tms tms;
  1069. X
  1070. X    (void) times(&tms);
  1071. X    return tms.tms_utime + tms.tms_stime;
  1072. X}
  1073. X
  1074. X#endif
  1075. X
  1076. X#if _ST
  1077. X
  1078. X#include <osbind.h>
  1079. X
  1080. Xclock_t
  1081. Xclock()
  1082. X{
  1083. X    long save;
  1084. X    clock_t c;
  1085. X
  1086. X    /* access the ST's 200 HZ system clock in protected memory */
  1087. X    save = Super(0L);
  1088. X    c = *((long *)0x04BA);
  1089. X    (void)Super(save);
  1090. X    return c;
  1091. X}
  1092. X
  1093. X#endif
  1094. X
  1095. END_OF_FILE
  1096.   if test 735 -ne `wc -c <'std/stdc/clock.c'`; then
  1097.     echo shar: \"'std/stdc/clock.c'\" unpacked with wrong size!
  1098.   fi
  1099.   # end of 'std/stdc/clock.c'
  1100. fi
  1101. if test -f 'std/stdc/fprintf.c' -a "${1}" != "-c" ; then 
  1102.   echo shar: Will not clobber existing file \"'std/stdc/fprintf.c'\"
  1103. else
  1104.   echo shar: Extracting \"'std/stdc/fprintf.c'\" \(732 characters\)
  1105.   sed "s/^X//" >'std/stdc/fprintf.c' <<'END_OF_FILE'
  1106. X/*
  1107. X * printf and fprintf
  1108. X */
  1109. X
  1110. X/* $Header */
  1111. X
  1112. X#if __STDC__
  1113. X#include <stdarg.h>
  1114. X#else
  1115. X#include <varargs.h>
  1116. X#endif
  1117. X#include <stdio.h>
  1118. X
  1119. X#if _V7 || _BSD
  1120. X
  1121. X/* printf to stdout */
  1122. Xint
  1123. X#if __STDC__
  1124. Xprintf(Const char *fmt, ...) {
  1125. X#else
  1126. Xprintf(va_alist) va_dcl
  1127. X{
  1128. X    char *fmt;
  1129. X#endif
  1130. X    va_list va;
  1131. X
  1132. X#if __STDC__
  1133. X    va_start(va, fmt);
  1134. X#else
  1135. X    va_start(va);
  1136. X    fmt = va_arg(va, char *);
  1137. X#endif
  1138. X    vfprintf(stdout, fmt, va);
  1139. X    va_end(va);
  1140. X    return 0;
  1141. X}
  1142. X
  1143. Xint
  1144. X#if __STDC__
  1145. Xfprintf(FILE *f, Const char *fmt, ...) {
  1146. X#else
  1147. Xfprintf(va_alist) va_dcl
  1148. X{
  1149. X    FILE *f;
  1150. X    char *fmt;
  1151. X#endif
  1152. X    va_list va;
  1153. X
  1154. X#if __STDC__
  1155. X    va_start(va, fmt);
  1156. X#else
  1157. X    va_start(va);
  1158. X    f = va_arg(va, FILE *);
  1159. X    fmt = va_arg(va, char *);
  1160. X#endif
  1161. X    vfprintf(f, fmt, va);
  1162. X    va_end(va);
  1163. X    return 0;
  1164. X}
  1165. X
  1166. X#endif
  1167. END_OF_FILE
  1168.   if test 732 -ne `wc -c <'std/stdc/fprintf.c'`; then
  1169.     echo shar: \"'std/stdc/fprintf.c'\" unpacked with wrong size!
  1170.   fi
  1171.   # end of 'std/stdc/fprintf.c'
  1172. fi
  1173. if test -f 'std/stdc/limits.h' -a "${1}" != "-c" ; then 
  1174.   echo shar: Will not clobber existing file \"'std/stdc/limits.h'\"
  1175. else
  1176.   echo shar: Extracting \"'std/stdc/limits.h'\" \(983 characters\)
  1177.   sed "s/^X//" >'std/stdc/limits.h' <<'END_OF_FILE'
  1178. X/* Implementation-defined limits */
  1179. X
  1180. X#if __STDC__
  1181. X#define    Signed    signed
  1182. X#else
  1183. X#define    Signed    
  1184. X#endif
  1185. X
  1186. X#define    CHAR_BIT    8
  1187. X
  1188. X#define    _S_MIN(type)    (-(Signed type)((unsigned type) ~0 >> 1) - 1)
  1189. X#define    _S_MAX(type)    ((Signed type)((unsigned type) ~0 >> 1))
  1190. X
  1191. X#define    UCHAR_MIN    ((unsigned char) 0)
  1192. X#define    UCHAR_MAX    ((unsigned char) ~0)
  1193. X#define    SCHAR_MIN    _S_MIN(char)
  1194. X#define    SCHAR_MAX    _S_MAX(char)
  1195. X
  1196. X/* some PCC compilers don't like the "elegant" definition of _UCHAR */
  1197. X/* let the poor user provide -D_UCHAR=0 or 1 */
  1198. X#ifndef _UCHAR
  1199. X#define    _UCHAR        ((char) ~0 == (unsigned char) ~0)
  1200. X#endif
  1201. X#define    CHAR_MIN    (_UCHAR ? UCHAR_MIN : SCHAR_MIN)
  1202. X#define    CHAR_MAX    (_UCHAR ? UCHAR_MAX : SCHAR_MAX)
  1203. X
  1204. X#define    USHRT_MAX    ((unsigned short) ~0)
  1205. X#define    SHRT_MIN    _S_MIN(short)
  1206. X#define    SHRT_MAX    _S_MAX(short)
  1207. X
  1208. X#define    UINT_MAX    ((unsigned int) ~0)
  1209. X#define    INT_MIN        _S_MIN(int)
  1210. X#define    INT_MAX        _S_MAX(int)
  1211. X
  1212. X#define    ULONG_MAX    ((unsigned long) ~0)
  1213. X#define    LONG_MIN    _S_MIN(long)
  1214. X#define    LONG_MAX    _S_MAX(long)
  1215. X
  1216. END_OF_FILE
  1217.   if test 983 -ne `wc -c <'std/stdc/limits.h'`; then
  1218.     echo shar: \"'std/stdc/limits.h'\" unpacked with wrong size!
  1219.   fi
  1220.   # end of 'std/stdc/limits.h'
  1221. fi
  1222. if test -f 'std/stdc/memcmp.c' -a "${1}" != "-c" ; then 
  1223.   echo shar: Will not clobber existing file \"'std/stdc/memcmp.c'\"
  1224. else
  1225.   echo shar: Extracting \"'std/stdc/memcmp.c'\" \(358 characters\)
  1226.   sed "s/^X//" >'std/stdc/memcmp.c' <<'END_OF_FILE'
  1227. X/* $Header$ */
  1228. X
  1229. X#include <string.h>
  1230. X
  1231. Xint
  1232. Xmemcmp(dap, sap, n)
  1233. X    Const Void *dap;
  1234. X    Const Void *sap;
  1235. X    register size_t n;
  1236. X{
  1237. X    register Const unsigned char *dp = (unsigned char Const *) dap;
  1238. X    register Const unsigned char *sp = (unsigned char Const *) sap;
  1239. X
  1240. X    if (n++ > 0)
  1241. X        while (--n > 0)
  1242. X            if (*dp++ != *sp++)
  1243. X                return *--dp - *--sp; /* (int)? */
  1244. X    return 0;
  1245. X}
  1246. X
  1247. END_OF_FILE
  1248.   if test 358 -ne `wc -c <'std/stdc/memcmp.c'`; then
  1249.     echo shar: \"'std/stdc/memcmp.c'\" unpacked with wrong size!
  1250.   fi
  1251.   # end of 'std/stdc/memcmp.c'
  1252. fi
  1253. if test -f 'std/stdc/memmove.c' -a "${1}" != "-c" ; then 
  1254.   echo shar: Will not clobber existing file \"'std/stdc/memmove.c'\"
  1255. else
  1256.   echo shar: Extracting \"'std/stdc/memmove.c'\" \(336 characters\)
  1257.   sed "s/^X//" >'std/stdc/memmove.c' <<'END_OF_FILE'
  1258. X/* $Header$ */
  1259. X
  1260. X#include <string.h>
  1261. X
  1262. XVoid *
  1263. Xmemmove(dap, sap, n)
  1264. X    Void *dap;
  1265. X    Const Void *sap;
  1266. X    register size_t n;
  1267. X{
  1268. X    register char *dp = dap, *sp = (Void*) sap;
  1269. X
  1270. X    if (n <= 0)
  1271. X        ;
  1272. X    else if (dp < sp)
  1273. X        do *dp++ = *sp++; while (--n > 0);
  1274. X    else if (dp > sp) {
  1275. X        dp += n;
  1276. X        sp += n;
  1277. X        do *--dp = *--sp; while (--n > 0);
  1278. X    }
  1279. X    return dap;
  1280. X}
  1281. X
  1282. X
  1283. END_OF_FILE
  1284.   if test 336 -ne `wc -c <'std/stdc/memmove.c'`; then
  1285.     echo shar: \"'std/stdc/memmove.c'\" unpacked with wrong size!
  1286.   fi
  1287.   # end of 'std/stdc/memmove.c'
  1288. fi
  1289. if test -f 'std/stdc/setvbuf.c' -a "${1}" != "-c" ; then 
  1290.   echo shar: Will not clobber existing file \"'std/stdc/setvbuf.c'\"
  1291. else
  1292.   echo shar: Extracting \"'std/stdc/setvbuf.c'\" \(1044 characters\)
  1293.   sed "s/^X//" >'std/stdc/setvbuf.c' <<'END_OF_FILE'
  1294. X/*
  1295. X * PD ksh needs an ANSI-compatible setvbuf.
  1296. X * if (buf == NULL) it must also allocate a buffer
  1297. X * and arrange for fclose to deallocate it.
  1298. X * the reason for doing setvbuf(f, (char *)NULL, _IOFBF, BUFSIZ)
  1299. X * in the shell is to avoid 4/8K buffers on BSD like systems.
  1300. X */
  1301. X
  1302. X/* $Header */
  1303. X
  1304. X#include <stdlib.h>
  1305. X#include <stdio.h>
  1306. X
  1307. X#if _BSD || _SYSV
  1308. Xint
  1309. Xsetvbuf(f, buf, type, size)
  1310. X    register FILE *f;
  1311. X    char *buf;
  1312. X    int type;
  1313. X    size_t size;
  1314. X{
  1315. X    if ((f->_flag&_IOMYBUF) && f->_base != NULL)
  1316. X        free(f->_base);
  1317. X    f->_flag &= ~(_IOMYBUF|_IONBF|_IOFBF|_IOLBF);
  1318. X    switch (type) {
  1319. X      case _IONBF:
  1320. X        size = 0;
  1321. X        buf = NULL;
  1322. X        break;
  1323. X      case _IOLBF:
  1324. X      case _IOFBF:
  1325. X        if (size == 0)
  1326. X            size = BUFSIZ;
  1327. X#if _V7
  1328. X        else if (size != BUFSIZ)
  1329. X            return -1;
  1330. X#endif
  1331. X        if (buf == NULL) {
  1332. X            buf = malloc(size);
  1333. X            if (buf == NULL)
  1334. X                return -1;
  1335. X            f->_flag |= _IOMYBUF;
  1336. X        }
  1337. X        break;
  1338. X      default:
  1339. X        return -1;
  1340. X    }
  1341. X    f->_flag |= type;
  1342. X    f->_base = f->_ptr = buf;
  1343. X    f->_cnt = 0;
  1344. X#if _BSD
  1345. X    f->_bufsiz = size;
  1346. X#endif
  1347. X#if _SYSV
  1348. X    _bufend(f) = buf + size;
  1349. X#endif
  1350. X    return 0;
  1351. X}
  1352. X#endif
  1353. X
  1354. END_OF_FILE
  1355.   if test 1044 -ne `wc -c <'std/stdc/setvbuf.c'`; then
  1356.     echo shar: \"'std/stdc/setvbuf.c'\" unpacked with wrong size!
  1357.   fi
  1358.   # end of 'std/stdc/setvbuf.c'
  1359. fi
  1360. if test -f 'std/stdc/sprintf.c' -a "${1}" != "-c" ; then 
  1361.   echo shar: Will not clobber existing file \"'std/stdc/sprintf.c'\"
  1362. else
  1363.   echo shar: Extracting \"'std/stdc/sprintf.c'\" \(795 characters\)
  1364.   sed "s/^X//" >'std/stdc/sprintf.c' <<'END_OF_FILE'
  1365. X/*
  1366. X * sprintf and vsprintf
  1367. X */
  1368. X
  1369. X/* $Header */
  1370. X
  1371. X#if __STDC__
  1372. X#include <stdarg.h>
  1373. X#else
  1374. X#include <varargs.h>
  1375. X#endif
  1376. X#include <stdio.h>
  1377. X
  1378. X#if _V7 || _BSD
  1379. X
  1380. Xint
  1381. X#if __STDC__
  1382. Xsprintf(char *s, Const char *fmt, ...) {
  1383. X#else
  1384. Xsprintf(va_alist) va_dcl
  1385. X{
  1386. X    char *s;
  1387. X    char *fmt;
  1388. X#endif
  1389. X    register va_list va;
  1390. X    int n;
  1391. X
  1392. X#if __STDC__
  1393. X    va_start(va, fmt);
  1394. X#else
  1395. X    va_start(va);
  1396. X    s = va_arg(va, char *);
  1397. X    fmt = va_arg(va, char *);
  1398. X#endif
  1399. X    n = vsprintf(s, fmt, va);
  1400. X    va_end(va);
  1401. X    return n;
  1402. X}
  1403. X
  1404. Xint
  1405. X#if __STDC__
  1406. Xvsprintf(char *s, const char *fmt, va_list va) {
  1407. X#else
  1408. Xvsprintf(s, fmt, va)
  1409. X    char *s;
  1410. X    char *fmt;
  1411. X    va_list va;
  1412. X{
  1413. X#endif
  1414. X    int n;
  1415. X    static FILE siob;
  1416. X
  1417. X    siob._flag = _IOWRT;
  1418. X    siob._base = siob._ptr = s;
  1419. X    siob._cnt = BUFSIZ;
  1420. X    siob._file = -1;
  1421. X
  1422. X    n = vfprintf(&siob, fmt, va);
  1423. X    *siob._ptr = 0;
  1424. X    return n;
  1425. X}
  1426. X
  1427. X#endif
  1428. X
  1429. END_OF_FILE
  1430.   if test 795 -ne `wc -c <'std/stdc/sprintf.c'`; then
  1431.     echo shar: \"'std/stdc/sprintf.c'\" unpacked with wrong size!
  1432.   fi
  1433.   # end of 'std/stdc/sprintf.c'
  1434. fi
  1435. if test -f 'std/stdc/stdarg.h' -a "${1}" != "-c" ; then 
  1436.   echo shar: Will not clobber existing file \"'std/stdc/stdarg.h'\"
  1437. else
  1438.   echo shar: Extracting \"'std/stdc/stdarg.h'\" \(619 characters\)
  1439.   sed "s/^X//" >'std/stdc/stdarg.h' <<'END_OF_FILE'
  1440. X#ifndef _STDARG_H
  1441. X#define _STDARG_H
  1442. X
  1443. Xtypedef char *va_list;
  1444. X
  1445. X/* Amount of space required in an argument list for an arg of type TYPE.
  1446. X   TYPE may alternatively be an expression whose type is used.  */
  1447. X
  1448. X#define __va_rounded_size(TYPE)  \
  1449. X  (((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))
  1450. X
  1451. X#define va_start(AP, LASTARG)                         \
  1452. X (AP = ((char *) &(LASTARG) + __va_rounded_size (LASTARG)))
  1453. X
  1454. Xvoid va_end (va_list);        /* Defined in gnulib */
  1455. X#define va_end(AP)
  1456. X
  1457. X#define va_arg(AP, TYPE)                        \
  1458. X (AP += __va_rounded_size (TYPE),                    \
  1459. X  *((TYPE *) (AP - __va_rounded_size (TYPE))))
  1460. X
  1461. X#endif /* _STDARG_H */
  1462. END_OF_FILE
  1463.   if test 619 -ne `wc -c <'std/stdc/stdarg.h'`; then
  1464.     echo shar: \"'std/stdc/stdarg.h'\" unpacked with wrong size!
  1465.   fi
  1466.   # end of 'std/stdc/stdarg.h'
  1467. fi
  1468. if test -f 'std/stdc/stddef.h' -a "${1}" != "-c" ; then 
  1469.   echo shar: Will not clobber existing file \"'std/stdc/stddef.h'\"
  1470. else
  1471.   echo shar: Extracting \"'std/stdc/stddef.h'\" \(630 characters\)
  1472.   sed "s/^X//" >'std/stdc/stddef.h' <<'END_OF_FILE'
  1473. X/* ANSI common definitions */
  1474. X
  1475. X/* $Header$ */
  1476. X
  1477. X#ifndef NULL
  1478. X#if __STDC__
  1479. X#define    NULL    (void*)0
  1480. X#else
  1481. X#define    NULL    0
  1482. X#endif
  1483. X#endif
  1484. X
  1485. X#if ! _STDDEF_H
  1486. X#define    _STDDEF_H 1
  1487. X
  1488. X/* doesn't really belong here, but the library function need it */
  1489. X#if __STDC__
  1490. X#define    ARGS(args)    args
  1491. X#define Void    void
  1492. X#define    Const    const
  1493. X#else
  1494. X#define    ARGS(args)    ()
  1495. X#define    Void    char
  1496. X#define    Const
  1497. X#endif
  1498. X
  1499. X#ifdef sparc
  1500. X# include <sys/stdtypes.h>
  1501. X#else
  1502. Xtypedef unsigned size_t;        /* may need long */
  1503. Xtypedef int ptrdiff_t;
  1504. X#endif /* sparc */
  1505. X#define    offsetof(type,id) ((size_t)&((type*)NULL)->id)
  1506. X
  1507. Xextern    int errno;        /* really belongs in <errno.h> */
  1508. X
  1509. X#endif
  1510. X
  1511. END_OF_FILE
  1512.   if test 630 -ne `wc -c <'std/stdc/stddef.h'`; then
  1513.     echo shar: \"'std/stdc/stddef.h'\" unpacked with wrong size!
  1514.   fi
  1515.   # end of 'std/stdc/stddef.h'
  1516. fi
  1517. if test -f 'std/stdc/stdio.sed' -a "${1}" != "-c" ; then 
  1518.   echo shar: Will not clobber existing file \"'std/stdc/stdio.sed'\"
  1519. else
  1520.   echo shar: Extracting \"'std/stdc/stdio.sed'\" \(724 characters\)
  1521.   sed "s/^X//" >'std/stdc/stdio.sed' <<'END_OF_FILE'
  1522. X/^#[     ]*include/d
  1523. X/^#[     ]*define[     ]*NULL/d
  1524. X/remove[     ]*([     ]*)/d
  1525. X/rename[     ]*([     ]*)/d
  1526. X/tmpfile[     ]*([     ]*)/d
  1527. X/tmpnam[     ]*([     ]*)/d
  1528. X/fopen[     ]*([     ]*)/d
  1529. X/freopen[     ]*([     ]*)/d
  1530. X/fdopen[     ]*([     ]*)/d
  1531. X/fflush[     ]*([     ]*)/d
  1532. X/fclose[     ]*([     ]*)/d
  1533. X/setbuf[     ]*([     ]*)/d
  1534. X/setvbuf[     ]*([     ]*)/d
  1535. X/fseek[     ]*([     ]*)/d
  1536. X/ftell[     ]*([     ]*)/d
  1537. X/rewind[     ]*([     ]*)/d
  1538. X/printf[     ]*([     ]*)/d
  1539. X/fprintf[     ]*([     ]*)/d
  1540. X/sprintf[     ]*([     ]*)/d
  1541. X/vprintf[     ]*([     ]*)/d
  1542. X/vfprintf[     ]*([     ]*)/d
  1543. X/vsprintf[     ]*([     ]*)/d
  1544. X/scanf[     ]*([     ]*)/d
  1545. X/fscanf[     ]*([     ]*)/d
  1546. X/sscanf[     ]*([     ]*)/d
  1547. X/fread[     ]*([     ]*)/d
  1548. X/frwrite[     ]*([     ]*)/d
  1549. X/fgetc[     ]*([     ]*)/d
  1550. X/fputc[     ]*([     ]*)/d
  1551. X/fgets[     ]*([     ]*)/d
  1552. X/fputs[     ]*([     ]*)/d
  1553. X/gets[     ]*([     ]*)/d
  1554. X/puts[     ]*([     ]*)/d
  1555. END_OF_FILE
  1556.   if test 724 -ne `wc -c <'std/stdc/stdio.sed'`; then
  1557.     echo shar: \"'std/stdc/stdio.sed'\" unpacked with wrong size!
  1558.   fi
  1559.   # end of 'std/stdc/stdio.sed'
  1560. fi
  1561. if test -f 'std/stdc/stdlib.h' -a "${1}" != "-c" ; then 
  1562.   echo shar: Will not clobber existing file \"'std/stdc/stdlib.h'\"
  1563. else
  1564.   echo shar: Extracting \"'std/stdc/stdlib.h'\" \(1104 characters\)
  1565.   sed "s/^X//" >'std/stdc/stdlib.h' <<'END_OF_FILE'
  1566. X/* ANSI utility functions */
  1567. X
  1568. X/* $Header: stdlib.h,v 1.1 88/03/09 21:52:59 egisin Locked $ */
  1569. X
  1570. X#if ! _STDLIB_H
  1571. X#define    _STDLIB_H 1
  1572. X
  1573. X#include <stddef.h>
  1574. X
  1575. Xdouble    atof ARGS((const char *s));
  1576. Xint    atoi ARGS((const char *s));
  1577. Xlong    atol ARGS((const char *s));
  1578. Xdouble    strtod ARGS((const char *s, char **));
  1579. Xlong    strtol ARGS((const char *s, char **, int base));
  1580. Xunsigned long    strtoul ARGS((const char *s, char **, int base));
  1581. Xint    rand ARGS((void));
  1582. Xvoid    srand ARGS((unsigned int seed));
  1583. XVoid   *malloc ARGS((size_t size));
  1584. XVoid   *realloc ARGS((void *ptr, size_t size));
  1585. XVoid   *calloc ARGS((size_t n, size_t size));
  1586. Xvoid    free ARGS((void *ptr));
  1587. Xvoid    abort ARGS((void));
  1588. Xint    atexit ARGS((void (*func)(void)));
  1589. Xvoid    exit ARGS((int status));
  1590. Xchar   *getenv ARGS((const char *name));
  1591. Xint    system ARGS((const char *cmd));
  1592. Xvoid   *bsearch ARGS ((const void *key, const void *base, size_t n, size_t size,
  1593. X               int (*compar)(const void *, const void *)));
  1594. Xvoid   *qsort ARGS ((const void *base, size_t n, size_t size,
  1595. X             int (*compar)(const void *, const void *)));
  1596. X#define    abs(a)    ((a) < 0 : -(a) : (a))
  1597. X
  1598. X#endif
  1599. X
  1600. END_OF_FILE
  1601.   if test 1104 -ne `wc -c <'std/stdc/stdlib.h'`; then
  1602.     echo shar: \"'std/stdc/stdlib.h'\" unpacked with wrong size!
  1603.   fi
  1604.   # end of 'std/stdc/stdlib.h'
  1605. fi
  1606. if test -f 'std/stdc/strchr.c' -a "${1}" != "-c" ; then 
  1607.   echo shar: Will not clobber existing file \"'std/stdc/strchr.c'\"
  1608. else
  1609.   echo shar: Extracting \"'std/stdc/strchr.c'\" \(423 characters\)
  1610.   sed "s/^X//" >'std/stdc/strchr.c' <<'END_OF_FILE'
  1611. X#include <string.h>
  1612. X
  1613. X/*
  1614. X * strchr - find first occurrence of a character in a string
  1615. X */
  1616. X
  1617. Xchar *                /* found char, or NULL if none */
  1618. Xstrchr(s, charwanted)
  1619. XConst char *s;
  1620. Xregister char charwanted;
  1621. X{
  1622. X    register Const char *scan;
  1623. X
  1624. X    /*
  1625. X     * The odd placement of the two tests is so NUL is findable.
  1626. X     */
  1627. X    for (scan = s; *scan != charwanted;)    /* ++ moved down for opt. */
  1628. X        if (*scan++ == '\0')
  1629. X            return(NULL);
  1630. X    return(scan);
  1631. X}
  1632. END_OF_FILE
  1633.   if test 423 -ne `wc -c <'std/stdc/strchr.c'`; then
  1634.     echo shar: \"'std/stdc/strchr.c'\" unpacked with wrong size!
  1635.   fi
  1636.   # end of 'std/stdc/strchr.c'
  1637. fi
  1638. if test -f 'std/stdc/strcmp.c' -a "${1}" != "-c" ; then 
  1639.   echo shar: Will not clobber existing file \"'std/stdc/strcmp.c'\"
  1640. else
  1641.   echo shar: Extracting \"'std/stdc/strcmp.c'\" \(758 characters\)
  1642.   sed "s/^X//" >'std/stdc/strcmp.c' <<'END_OF_FILE'
  1643. X#include <string.h>
  1644. X
  1645. X/* Modified by Eric Gisin */
  1646. X
  1647. X/*
  1648. X * strcmp - compare string s1 to s2
  1649. X */
  1650. X
  1651. Xint                /* <0 for <, 0 for ==, >0 for > */
  1652. Xstrcmp(s1, s2)
  1653. XConst char *s1;
  1654. XConst char *s2;
  1655. X{
  1656. X    register Const char *scan1;
  1657. X    register Const char *scan2;
  1658. X#if 0                /* some machines prefer int to char */
  1659. X    register int c1, c2;
  1660. X#else
  1661. X    register char c1, c2;
  1662. X#endif
  1663. X
  1664. X    scan1 = s1;
  1665. X    scan2 = s2;
  1666. X    while ((c1 = *scan1++) == (c2 = *scan2++) && c1 != 0)
  1667. X        ;
  1668. X
  1669. X    /*
  1670. X     * The following case analysis is necessary so that characters
  1671. X     * which look negative collate low against normal characters but
  1672. X     * high against the end-of-string NUL.
  1673. X     */
  1674. X    if (c1 == '\0' && c2 == '\0')
  1675. X        return(0);
  1676. X    else if (c1 == '\0')
  1677. X        return(-1);
  1678. X    else if (c2 == '\0')
  1679. X        return(1);
  1680. X    else
  1681. X        return(c1 - c2);
  1682. X}
  1683. END_OF_FILE
  1684.   if test 758 -ne `wc -c <'std/stdc/strcmp.c'`; then
  1685.     echo shar: \"'std/stdc/strcmp.c'\" unpacked with wrong size!
  1686.   fi
  1687.   # end of 'std/stdc/strcmp.c'
  1688. fi
  1689. if test -f 'std/stdc/strcspn.c' -a "${1}" != "-c" ; then 
  1690.   echo shar: Will not clobber existing file \"'std/stdc/strcspn.c'\"
  1691. else
  1692.   echo shar: Extracting \"'std/stdc/strcspn.c'\" \(467 characters\)
  1693.   sed "s/^X//" >'std/stdc/strcspn.c' <<'END_OF_FILE'
  1694. X#include <string.h>
  1695. X
  1696. X/*
  1697. X * strcspn - find length of initial segment of s consisting entirely
  1698. X * of characters not from reject
  1699. X */
  1700. X
  1701. Xsize_t
  1702. Xstrcspn(s, reject)
  1703. XConst char *s;
  1704. XConst char *reject;
  1705. X{
  1706. X    register Const char *scan;
  1707. X    register Const char *rscan;
  1708. X    register size_t count;
  1709. X
  1710. X    count = 0;
  1711. X    for (scan = s; *scan != '\0'; scan++) {
  1712. X        for (rscan = reject; *rscan != '\0';)    /* ++ moved down. */
  1713. X            if (*scan == *rscan++)
  1714. X                return(count);
  1715. X        count++;
  1716. X    }
  1717. X    return(count);
  1718. X}
  1719. END_OF_FILE
  1720.   if test 467 -ne `wc -c <'std/stdc/strcspn.c'`; then
  1721.     echo shar: \"'std/stdc/strcspn.c'\" unpacked with wrong size!
  1722.   fi
  1723.   # end of 'std/stdc/strcspn.c'
  1724. fi
  1725. if test -f 'std/stdc/string.h' -a "${1}" != "-c" ; then 
  1726.   echo shar: Will not clobber existing file \"'std/stdc/string.h'\"
  1727. else
  1728.   echo shar: Extracting \"'std/stdc/string.h'\" \(1310 characters\)
  1729.   sed "s/^X//" >'std/stdc/string.h' <<'END_OF_FILE'
  1730. X/* ANSI string handling (missing wide char stuff) */
  1731. X
  1732. X#if ! _STRING_H
  1733. X#define _STRING_H 1
  1734. X
  1735. X#include <stddef.h>        /* define NULL and size_t */
  1736. X
  1737. X#if __STDC__
  1738. X#define    ARGS(args)    args
  1739. X#define    Void    void
  1740. X#else
  1741. X#define    ARGS(args)    ()
  1742. X#define    Void    char
  1743. X#endif
  1744. X
  1745. XVoid   *memcpy ARGS((Void *s1, const Void *s2, size_t));
  1746. XVoid   *memmove ARGS((Void *s1, const Void *s2, size_t));
  1747. Xint    memcmp ARGS((const Void *s1, const Void *s2, size_t));
  1748. XVoid   *memchr ARGS((const Void *s, int c, size_t));
  1749. XVoid   *memset ARGS((Void *s, int c, size_t));
  1750. Xsize_t    strlen ARGS((const char *s));
  1751. Xchar   *strcpy ARGS((char *s1, const char *s2));
  1752. Xchar   *strncpy ARGS((char *s1, const char *s2, size_t));
  1753. Xchar   *strcat ARGS((char *s1, const char *s2));
  1754. Xchar   *strncat ARGS((char *s1, const char *s2, size_t));
  1755. Xint    strcmp ARGS((const char *s1, const char *s2));
  1756. Xint    strncmp ARGS((const char *s1, const char *s2, size_t));
  1757. Xchar   *strchr ARGS((const char *s1, int c));
  1758. Xchar   *strrchr ARGS((const char *s1, int c));
  1759. Xsize_t    strspn ARGS((const char *s1, const char *s2));
  1760. Xsize_t    strcspn ARGS((const char *s1, const char *s2));
  1761. Xchar   *strpbrk ARGS((const char *s1, const char *s2));
  1762. Xchar   *strstr ARGS((const char *s1, const char *s2));
  1763. Xchar   *strtok ARGS((char *s1, const char *s2));
  1764. Xchar   *strerror ARGS((int errno));
  1765. X
  1766. X#endif /* _STRING_H */
  1767. X
  1768. END_OF_FILE
  1769.   if test 1310 -ne `wc -c <'std/stdc/string.h'`; then
  1770.     echo shar: \"'std/stdc/string.h'\" unpacked with wrong size!
  1771.   fi
  1772.   # end of 'std/stdc/string.h'
  1773. fi
  1774. if test -f 'std/stdc/strncat.c' -a "${1}" != "-c" ; then 
  1775.   echo shar: Will not clobber existing file \"'std/stdc/strncat.c'\"
  1776. else
  1777.   echo shar: Extracting \"'std/stdc/strncat.c'\" \(427 characters\)
  1778.   sed "s/^X//" >'std/stdc/strncat.c' <<'END_OF_FILE'
  1779. X#include <string.h>
  1780. X
  1781. X/*
  1782. X * strncat - append at most n characters of string src to dst
  1783. X */
  1784. Xchar *                /* dst */
  1785. Xstrncat(dst, src, n)
  1786. Xchar *dst;
  1787. XConst char *src;
  1788. Xsize_t n;
  1789. X{
  1790. X    register char *dscan;
  1791. X    register Const char *sscan;
  1792. X    register size_t count;
  1793. X
  1794. X    for (dscan = dst; *dscan != '\0'; dscan++)
  1795. X        continue;
  1796. X    sscan = src;
  1797. X    count = n;
  1798. X    while (*sscan != '\0' && --count >= 0)
  1799. X        *dscan++ = *sscan++;
  1800. X    *dscan++ = '\0';
  1801. X    return(dst);
  1802. X}
  1803. END_OF_FILE
  1804.   if test 427 -ne `wc -c <'std/stdc/strncat.c'`; then
  1805.     echo shar: \"'std/stdc/strncat.c'\" unpacked with wrong size!
  1806.   fi
  1807.   # end of 'std/stdc/strncat.c'
  1808. fi
  1809. if test -f 'std/stdc/strncmp.c' -a "${1}" != "-c" ; then 
  1810.   echo shar: Will not clobber existing file \"'std/stdc/strncmp.c'\"
  1811. else
  1812.   echo shar: Extracting \"'std/stdc/strncmp.c'\" \(778 characters\)
  1813.   sed "s/^X//" >'std/stdc/strncmp.c' <<'END_OF_FILE'
  1814. X#include <string.h>
  1815. X
  1816. X/*
  1817. X * strncmp - compare at most n characters of string s1 to s2
  1818. X */
  1819. X
  1820. Xint                /* <0 for <, 0 for ==, >0 for > */
  1821. Xstrncmp(s1, s2, n)
  1822. XConst char *s1;
  1823. XConst char *s2;
  1824. Xsize_t n;
  1825. X{
  1826. X    register Const char *scan1;
  1827. X    register Const char *scan2;
  1828. X    register size_t count;
  1829. X
  1830. X    scan1 = s1;
  1831. X    scan2 = s2;
  1832. X    count = n;
  1833. X    while (--count >= 0 && *scan1 != '\0' && *scan1 == *scan2) {
  1834. X        scan1++;
  1835. X        scan2++;
  1836. X    }
  1837. X    if (count < 0)
  1838. X        return(0);
  1839. X
  1840. X    /*
  1841. X     * The following case analysis is necessary so that characters
  1842. X     * which look negative collate low against normal characters but
  1843. X     * high against the end-of-string NUL.
  1844. X     */
  1845. X    if (*scan1 == '\0' && *scan2 == '\0')
  1846. X        return(0);
  1847. X    else if (*scan1 == '\0')
  1848. X        return(-1);
  1849. X    else if (*scan2 == '\0')
  1850. X        return(1);
  1851. X    else
  1852. X        return(*scan1 - *scan2);
  1853. X}
  1854. END_OF_FILE
  1855.   if test 778 -ne `wc -c <'std/stdc/strncmp.c'`; then
  1856.     echo shar: \"'std/stdc/strncmp.c'\" unpacked with wrong size!
  1857.   fi
  1858.   # end of 'std/stdc/strncmp.c'
  1859. fi
  1860. if test -f 'std/stdc/strncpy.c' -a "${1}" != "-c" ; then 
  1861.   echo shar: Will not clobber existing file \"'std/stdc/strncpy.c'\"
  1862. else
  1863.   echo shar: Extracting \"'std/stdc/strncpy.c'\" \(410 characters\)
  1864.   sed "s/^X//" >'std/stdc/strncpy.c' <<'END_OF_FILE'
  1865. X#include <string.h>
  1866. X
  1867. X/*
  1868. X * strncpy - copy at most n characters of string src to dst
  1869. X */
  1870. Xchar *                /* dst */
  1871. Xstrncpy(dst, src, n)
  1872. Xchar *dst;
  1873. XConst char *src;
  1874. Xsize_t n;
  1875. X{
  1876. X    register char *dscan;
  1877. X    register Const char *sscan;
  1878. X    register size_t count;
  1879. X
  1880. X    dscan = dst;
  1881. X    sscan = src;
  1882. X    count = n;
  1883. X    while (--count >= 0 && (*dscan++ = *sscan++) != '\0')
  1884. X        continue;
  1885. X    while (--count >= 0)
  1886. X        *dscan++ = '\0';
  1887. X    return(dst);
  1888. X}
  1889. END_OF_FILE
  1890.   if test 410 -ne `wc -c <'std/stdc/strncpy.c'`; then
  1891.     echo shar: \"'std/stdc/strncpy.c'\" unpacked with wrong size!
  1892.   fi
  1893.   # end of 'std/stdc/strncpy.c'
  1894. fi
  1895. if test -f 'std/stdc/strpbrk.c' -a "${1}" != "-c" ; then 
  1896.   echo shar: Will not clobber existing file \"'std/stdc/strpbrk.c'\"
  1897. else
  1898.   echo shar: Extracting \"'std/stdc/strpbrk.c'\" \(427 characters\)
  1899.   sed "s/^X//" >'std/stdc/strpbrk.c' <<'END_OF_FILE'
  1900. X#include <string.h>
  1901. X
  1902. X/*
  1903. X * strpbrk - find first occurrence of any char from breakat in s
  1904. X */
  1905. X
  1906. Xchar *                /* found char, or NULL if none */
  1907. Xstrpbrk(s, breakat)
  1908. XConst char *s;
  1909. XConst char *breakat;
  1910. X{
  1911. X    register Const char *sscan;
  1912. X    register Const char *bscan;
  1913. X
  1914. X    for (sscan = s; *sscan != '\0'; sscan++) {
  1915. X        for (bscan = breakat; *bscan != '\0';)    /* ++ moved down. */
  1916. X            if (*sscan == *bscan++)
  1917. X                return(sscan);
  1918. X    }
  1919. X    return(NULL);
  1920. X}
  1921. END_OF_FILE
  1922.   if test 427 -ne `wc -c <'std/stdc/strpbrk.c'`; then
  1923.     echo shar: \"'std/stdc/strpbrk.c'\" unpacked with wrong size!
  1924.   fi
  1925.   # end of 'std/stdc/strpbrk.c'
  1926. fi
  1927. if test -f 'std/stdc/strrchr.c' -a "${1}" != "-c" ; then 
  1928.   echo shar: Will not clobber existing file \"'std/stdc/strrchr.c'\"
  1929. else
  1930.   echo shar: Extracting \"'std/stdc/strrchr.c'\" \(415 characters\)
  1931.   sed "s/^X//" >'std/stdc/strrchr.c' <<'END_OF_FILE'
  1932. X#include <string.h>
  1933. X
  1934. X/*
  1935. X * strrchr - find last occurrence of a character in a string
  1936. X */
  1937. X
  1938. Xchar *                /* found char, or NULL if none */
  1939. Xstrrchr(s, charwanted)
  1940. XConst char *s;
  1941. Xregister char charwanted;
  1942. X{
  1943. X    register Const char *scan;
  1944. X    register Const char *place;
  1945. X
  1946. X    place = NULL;
  1947. X    for (scan = s; *scan != '\0'; scan++)
  1948. X        if (*scan == charwanted)
  1949. X            place = scan;
  1950. X    if (charwanted == '\0')
  1951. X        return(scan);
  1952. X    return(place);
  1953. X}
  1954. END_OF_FILE
  1955.   if test 415 -ne `wc -c <'std/stdc/strrchr.c'`; then
  1956.     echo shar: \"'std/stdc/strrchr.c'\" unpacked with wrong size!
  1957.   fi
  1958.   # end of 'std/stdc/strrchr.c'
  1959. fi
  1960. if test -f 'std/stdc/strspn.c' -a "${1}" != "-c" ; then 
  1961.   echo shar: Will not clobber existing file \"'std/stdc/strspn.c'\"
  1962. else
  1963.   echo shar: Extracting \"'std/stdc/strspn.c'\" \(483 characters\)
  1964.   sed "s/^X//" >'std/stdc/strspn.c' <<'END_OF_FILE'
  1965. X#include <string.h>
  1966. X
  1967. X/*
  1968. X * strspn - find length of initial segment of s consisting entirely
  1969. X * of characters from accept
  1970. X */
  1971. X
  1972. Xsize_t
  1973. Xstrspn(s, accept)
  1974. XConst char *s;
  1975. XConst char *accept;
  1976. X{
  1977. X    register Const char *sscan;
  1978. X    register Const char *ascan;
  1979. X    register size_t count;
  1980. X
  1981. X    count = 0;
  1982. X    for (sscan = s; *sscan != '\0'; sscan++) {
  1983. X        for (ascan = accept; *ascan != '\0'; ascan++)
  1984. X            if (*sscan == *ascan)
  1985. X                break;
  1986. X        if (*ascan == '\0')
  1987. X            return(count);
  1988. X        count++;
  1989. X    }
  1990. X    return(count);
  1991. X}
  1992. END_OF_FILE
  1993.   if test 483 -ne `wc -c <'std/stdc/strspn.c'`; then
  1994.     echo shar: \"'std/stdc/strspn.c'\" unpacked with wrong size!
  1995.   fi
  1996.   # end of 'std/stdc/strspn.c'
  1997. fi
  1998. if test -f 'std/stdc/strstr.c' -a "${1}" != "-c" ; then 
  1999.   echo shar: Will not clobber existing file \"'std/stdc/strstr.c'\"
  2000. else
  2001.   echo shar: Extracting \"'std/stdc/strstr.c'\" \(595 characters\)
  2002.   sed "s/^X//" >'std/stdc/strstr.c' <<'END_OF_FILE'
  2003. X#include <string.h>
  2004. X
  2005. X/*
  2006. X * strstr - find first occurrence of wanted in s
  2007. X */
  2008. X
  2009. Xchar *                /* found string, or NULL if none */
  2010. Xstrstr(s, wanted)
  2011. XConst char *s;
  2012. XConst char *wanted;
  2013. X{
  2014. X    register Const char *scan;
  2015. X    register size_t len;
  2016. X    register char firstc;
  2017. X
  2018. X    /*
  2019. X     * The odd placement of the two tests is so "" is findable.
  2020. X     * Also, we inline the first char for speed.
  2021. X     * The ++ on scan has been moved down for optimization.
  2022. X     */
  2023. X    firstc = *wanted;
  2024. X    len = strlen(wanted);
  2025. X    for (scan = s; *scan != firstc || strncmp(scan, wanted, len) != 0; )
  2026. X        if (*scan++ == '\0')
  2027. X            return(NULL);
  2028. X    return(scan);
  2029. X}
  2030. END_OF_FILE
  2031.   if test 595 -ne `wc -c <'std/stdc/strstr.c'`; then
  2032.     echo shar: \"'std/stdc/strstr.c'\" unpacked with wrong size!
  2033.   fi
  2034.   # end of 'std/stdc/strstr.c'
  2035. fi
  2036. if test -f 'std/stdc/strtok.c' -a "${1}" != "-c" ; then 
  2037.   echo shar: Will not clobber existing file \"'std/stdc/strtok.c'\"
  2038. else
  2039.   echo shar: Extracting \"'std/stdc/strtok.c'\" \(1108 characters\)
  2040.   sed "s/^X//" >'std/stdc/strtok.c' <<'END_OF_FILE'
  2041. X#include <string.h>
  2042. X
  2043. X/*
  2044. X * Get next token from string s (NULL on 2nd, 3rd, etc. calls),
  2045. X * where tokens are nonempty strings separated by runs of
  2046. X * chars from delim.  Writes NULs into s to end tokens.  delim need not
  2047. X * remain constant from call to call.
  2048. X */
  2049. X
  2050. Xstatic char *scanpoint = NULL;
  2051. X
  2052. Xchar *                /* NULL if no token left */
  2053. Xstrtok(s, delim)
  2054. Xchar *s;
  2055. Xregister Const char *delim;
  2056. X{
  2057. X    register char *scan;
  2058. X    char *tok;
  2059. X    register Const char *dscan;
  2060. X
  2061. X    if (s == NULL && scanpoint == NULL)
  2062. X        return(NULL);
  2063. X    if (s != NULL)
  2064. X        scan = s;
  2065. X    else
  2066. X        scan = scanpoint;
  2067. X
  2068. X    /*
  2069. X     * Scan leading delimiters.
  2070. X     */
  2071. X    for (; *scan != '\0'; scan++) {
  2072. X        for (dscan = delim; *dscan != '\0'; dscan++)
  2073. X            if (*scan == *dscan)
  2074. X                break;
  2075. X        if (*dscan == '\0')
  2076. X            break;
  2077. X    }
  2078. X    if (*scan == '\0') {
  2079. X        scanpoint = NULL;
  2080. X        return(NULL);
  2081. X    }
  2082. X
  2083. X    tok = scan;
  2084. X
  2085. X    /*
  2086. X     * Scan token.
  2087. X     */
  2088. X    for (; *scan != '\0'; scan++) {
  2089. X        for (dscan = delim; *dscan != '\0';)    /* ++ moved down. */
  2090. X            if (*scan == *dscan++) {
  2091. X                scanpoint = scan+1;
  2092. X                *scan = '\0';
  2093. X                return(tok);
  2094. X            }
  2095. X    }
  2096. X
  2097. X    /*
  2098. X     * Reached end of string.
  2099. X     */
  2100. X    scanpoint = NULL;
  2101. X    return(tok);
  2102. X}
  2103. END_OF_FILE
  2104.   if test 1108 -ne `wc -c <'std/stdc/strtok.c'`; then
  2105.     echo shar: \"'std/stdc/strtok.c'\" unpacked with wrong size!
  2106.   fi
  2107.   # end of 'std/stdc/strtok.c'
  2108. fi
  2109. if test -f 'std/stdc/time.h' -a "${1}" != "-c" ; then 
  2110.   echo shar: Will not clobber existing file \"'std/stdc/time.h'\"
  2111. else
  2112.   echo shar: Extracting \"'std/stdc/time.h'\" \(951 characters\)
  2113.   sed "s/^X//" >'std/stdc/time.h' <<'END_OF_FILE'
  2114. X/* time, time/date conversion */
  2115. X
  2116. X#if ! _TIME_H
  2117. X#define    _TIME_H 1
  2118. X
  2119. X#include <stddef.h>        /* need size_t */
  2120. X
  2121. X#ifndef sparc
  2122. Xtypedef long time_t;
  2123. Xtypedef long clock_t;        /* seconds/CLK_TCK */
  2124. X#endif
  2125. X
  2126. X#if _V7 || _SYSV
  2127. X#define    CLK_TCK    60        /* todo: get from <sys/param.h> */
  2128. X#endif
  2129. X
  2130. X#if _BSD
  2131. X#define    CLK_TCK    100
  2132. X#endif
  2133. X
  2134. X#if _ST
  2135. X#define    CLK_TCK    200        /* ST system clock */
  2136. X#endif
  2137. X
  2138. Xstruct tm {
  2139. X    int    tm_sec, tm_min, tm_hour;
  2140. X    int    tm_mday, tm_mon, tm_year, tm_wday, tm_yday;
  2141. X    int    tm_isdst;
  2142. X    long    tm_gmtoff;    /* BSD */
  2143. X    char   *tm_zone;    /* BSD */
  2144. X};
  2145. X
  2146. Xclock_t    clock ARGS((void));
  2147. Xtime_t    time ARGS((time_t *tp));
  2148. X#define    difftime(t1, t2)    (double)((t2)-(t1))
  2149. Xtime_t    mktime ARGS((struct tm *tmp));
  2150. Xchar   *asctime ARGS((const struct tm *tmp));
  2151. Xchar   *ctime ARGS((const time_t *tp));
  2152. Xstruct tm *gmtime ARGS((const time_t *tp));
  2153. Xstruct tm *localtime ARGS((const time_t *tp));
  2154. Xsize_t    strftime ARGS((char *buf, size_t len, const char *fmt, const struct tm *tmp));
  2155. X
  2156. X#endif
  2157. X
  2158. END_OF_FILE
  2159.   if test 951 -ne `wc -c <'std/stdc/time.h'`; then
  2160.     echo shar: \"'std/stdc/time.h'\" unpacked with wrong size!
  2161.   fi
  2162.   # end of 'std/stdc/time.h'
  2163. fi
  2164. if test -f 'std/stdc/types.h' -a "${1}" != "-c" ; then 
  2165.   echo shar: Will not clobber existing file \"'std/stdc/types.h'\"
  2166. else
  2167.   echo shar: Extracting \"'std/stdc/types.h'\" \(371 characters\)
  2168.   sed "s/^X//" >'std/stdc/types.h' <<'END_OF_FILE'
  2169. X/* work around multiple typedefs in stddef.h and sys/types.h */
  2170. X
  2171. X#include <stddef.h>        /* defines size_t and ptrdiff_t */
  2172. X#include <time.h>        /* defines time_t and clock_t */
  2173. X
  2174. X/* "inhibit" the typedefs in sys/types.h */
  2175. X#define size_t _size_t
  2176. X#define    time_t _time_t
  2177. X#define    clock_t _clock_t
  2178. X#include "/./usr/include/sys/types.h"
  2179. X#undef    size_t
  2180. X#undef    time_t
  2181. X#undef    clock_t
  2182. X
  2183. END_OF_FILE
  2184.   if test 371 -ne `wc -c <'std/stdc/types.h'`; then
  2185.     echo shar: \"'std/stdc/types.h'\" unpacked with wrong size!
  2186.   fi
  2187.   # end of 'std/stdc/types.h'
  2188. fi
  2189. echo shar: End of archive 8 \(of 9\).
  2190. cp /dev/null ark8isdone
  2191. MISSING=""
  2192. for I in 1 2 3 4 5 6 7 8 9 ; do
  2193.     if test ! -f ark${I}isdone ; then
  2194.     MISSING="${MISSING} ${I}"
  2195.     fi
  2196. done
  2197. if test "${MISSING}" = "" ; then
  2198.     echo You have unpacked all 9 archives.
  2199.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  2200. else
  2201.     echo You still must unpack the following archives:
  2202.     echo "        " ${MISSING}
  2203. fi
  2204. exit 0
  2205. exit 0 # Just in case...
  2206. -- 
  2207. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  2208. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  2209. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  2210. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  2211.